1. Field of the Invention
The present invention relates to CORDIC rotator systems and, more particularly, to simplified CORDIC rotators in CDMA communication systems and other hardware implementations.
2. Prior Art
Many algorithms designed for communications, navigation, robotics, and digital signal processing generally do not translate efficiently to a hardware implementation and must rely upon software to execute.
In one example, many digital communications systems utilize amplitude and phase modulation, producing complex baseband signals, which are pulse shaped before modulation to the carrier frequency. The complex, baseband signals are typically represented as an in-phase signal (I) and a quadrature signal (Q). For many modulation formats and multiple access schemes, these complex baseband signals have large peak values relative to the average signal value. When the peak-to-average power ratio of the baseband signal is large, the signal requires reduction in the power amplifier to avoid saturation. The peak-to-average power ratio limits the average power that can be transmitted due to the finite maximum output power of the power amplifier in the RF front-end (RFFE). Alternatively, for a fixed average transmit power, the peak-to-average power ratio will determine the required maximum output power of the RF power amplifier. In both cases, a decreased peak to average power ratio is desirable.
To decrease the peak-to-average power ratio of the signal, many digital communications systems employ clipping, also termed amplitude limiting, on the baseband complex signal. Clipping suppresses the signal peaks, reducing the peak-to-average power ratio of the signal with minimal signal distortion. The most common and effective form of clipping is circular clipping, which preserves the angle of the complex signal while limiting the maximum magnitude. Circular clipping follows the input-output relation,
      I    out    =      {                                                                      I                in                                                    ⋮                                                                                            I                    in                    2                                    +                                      Q                    in                    2                                                  ≤                                  P                                      p                    out                                                                                                                                            I                  in                                ·                                                                            P                                              P                        out                                                              /                                          (                                                                        I                          in                          2                                                +                                                  Q                          in                          2                                                                    )                                                                                                          ⋮                                                                                            I                    in                    2                                    +                                      Q                    in                    2                                                  >                                  P                                      p                    out                                                                                      ⁢                                  ⁢                  Q          out                    =              {                                                                              Q                  in                                                            ⋮                                                                                                        I                      in                      2                                        +                                          Q                      in                      2                                                        ≤                                      P                                          p                      out                                                                                                                                                                Q                    in                                    ·                                                                                    P                                                  P                          out                                                                    /                                              (                                                                              I                            in                            2                                                    +                                                      Q                            in                            2                                                                          )                                                                                                                        ⋮                                                                                                        I                      in                      2                                        +                                          Q                      in                      2                                                        >                                      P                                          p                      out                                                                                                    .                    
In hardware implementations, circular clipping is often implemented using a look-up table (LUT). A LUT implementation avoids the need to compute the constellation magnitude, implement the square root, and division functions as are done in U.S. Pat. No. 6,266,320 to Hedberg et al.; these functions, as well as others, are complex operations for digital hardware. With a LUT-implementation, the LUT holds the output I and Q (Iout,Qout) values for all possible combinations of input values (Iin, Qin). When the number of possible input I and Q values is small, the LUT approach is attractive. However, as the number of possible I and Q input values increases the size of the memory used to store the LUT must grow proportionately. With 10-bit input (I,Q) values and 8-bit (I,Q) output values, the LUT would require a memory of size 2,097,152 bytes. If the input constellation is symmetric in the four quadrants, the LUT size may be reduced by a factor of four, but still requires a large memory of size 524,288 bytes. In many applications a LUT-based circular clipper may be impractical when the number of possible input I and Q values is large.
In still other hardware implementations to solve complex algorithms is the use of CORDIC rotators. Yet, even CORDIC rotators require the use of LUTs.
Therefore, it is desirable to provide a hardware efficient method and system to solve complex algorithms.